// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.purchase.plans.product;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.PurchasePlansProduct;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(PurchasePlansProduct.class)
@Setter
@Getter
public class PurchasePlansProductSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "PurchasePlansProduct".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("parentPurchasePlans", "pp");
    map.put("product", "p");
    map.put("sid", "si");
    map.put("fnsku", "lf");
    map.put("supplierId", "s");
    map.put("wid", "w");
    map.put("psqId", "psq");
    map.put("cgUid", "su");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 所属采购计划
   */
  private Long parentPurchasePlans;

  /**
   * 所属采购计划 比较(eq)
   */
  private Long parentPurchasePlansEq;
  /**
   * 所属采购计划 比较(neq)
   */
  private Long parentPurchasePlansNeq;
  /**
   * 所属采购计划 比较(gt)
   */
  private Long parentPurchasePlansGt;
  /**
   * 所属采购计划 比较(gte)
   */
  private Long parentPurchasePlansGte;
  /**
   * 所属采购计划 比较(lt)
   */
  private Long parentPurchasePlansLt;
  /**
   * 所属采购计划 比较(lte)
   */
  private Long parentPurchasePlansLte;
  /**
   * 所属采购计划 比较(contains)
   */
  private Long parentPurchasePlansContains;
  /**
   * 所属采购计划 比较(notcontains)
   */
  private Long parentPurchasePlansNotcontains;
  /**
   * 所属采购计划 比较(startswith)
   */
  private Long parentPurchasePlansStartswith;
  /**
   * 所属采购计划 比较(endswith)
   */
  private Long parentPurchasePlansEndswith;
  /**
   * 所属采购计划 比较(isnull)
   */
  private Boolean parentPurchasePlansIsnull;
  /**
   * 所属采购计划 比较(isnotnull)
   */
  private Boolean parentPurchasePlansIsnotnull;
  /**
   * 所属采购计划的创建批次号 比较(eq)
   */
  private String parentPurchasePlansPpgSnEq;
  /**
   * 所属采购计划的创建批次号 比较(neq)
   */
  private String parentPurchasePlansPpgSnNeq;
  /**
   * 所属采购计划的创建批次号 比较(gt)
   */
  private String parentPurchasePlansPpgSnGt;
  /**
   * 所属采购计划的创建批次号 比较(gte)
   */
  private String parentPurchasePlansPpgSnGte;
  /**
   * 所属采购计划的创建批次号 比较(lt)
   */
  private String parentPurchasePlansPpgSnLt;
  /**
   * 所属采购计划的创建批次号 比较(lte)
   */
  private String parentPurchasePlansPpgSnLte;
  /**
   * 所属采购计划的创建批次号 比较(contains)
   */
  private String parentPurchasePlansPpgSnContains;
  /**
   * 所属采购计划的创建批次号 比较(notcontains)
   */
  private String parentPurchasePlansPpgSnNotcontains;
  /**
   * 所属采购计划的创建批次号 比较(startswith)
   */
  private String parentPurchasePlansPpgSnStartswith;
  /**
   * 所属采购计划的创建批次号 比较(endswith)
   */
  private String parentPurchasePlansPpgSnEndswith;
  /**
   * 所属采购计划的创建批次号 比较(isnull)
   */
  private Boolean parentPurchasePlansPpgSnIsnull;
  /**
   * 所属采购计划的创建批次号 比较(isnotnull)
   */
  private Boolean parentPurchasePlansPpgSnIsnotnull;

  /**
   * 所属采购计划(范围搜索)
   */
  private List<Long> parentPurchasePlansInList;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 计划编号(模糊搜索)
   */
  private String planSn;

  /**
   * 计划编号 比较(eq)
   */
  private String planSnEq;
  /**
   * 计划编号 比较(neq)
   */
  private String planSnNeq;
  /**
   * 计划编号 比较(gt)
   */
  private String planSnGt;
  /**
   * 计划编号 比较(gte)
   */
  private String planSnGte;
  /**
   * 计划编号 比较(lt)
   */
  private String planSnLt;
  /**
   * 计划编号 比较(lte)
   */
  private String planSnLte;
  /**
   * 计划编号 比较(contains)
   */
  private String planSnContains;
  /**
   * 计划编号 比较(notcontains)
   */
  private String planSnNotcontains;
  /**
   * 计划编号 比较(startswith)
   */
  private String planSnStartswith;
  /**
   * 计划编号 比较(endswith)
   */
  private String planSnEndswith;
  /**
   * 计划编号 比较(isnull)
   */
  private Boolean planSnIsnull;
  /**
   * 计划编号 比较(isnotnull)
   */
  private Boolean planSnIsnotnull;

  /**
   * 计划编号(精确搜索)
   */
  private List<String> planSnInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 是否有 图片
   */
  private Boolean picUrl;

  /**
   * 产品
   */
  private Long product;

  /**
   * 产品 比较(eq)
   */
  private Long productEq;
  /**
   * 产品 比较(neq)
   */
  private Long productNeq;
  /**
   * 产品 比较(gt)
   */
  private Long productGt;
  /**
   * 产品 比较(gte)
   */
  private Long productGte;
  /**
   * 产品 比较(lt)
   */
  private Long productLt;
  /**
   * 产品 比较(lte)
   */
  private Long productLte;
  /**
   * 产品 比较(contains)
   */
  private Long productContains;
  /**
   * 产品 比较(notcontains)
   */
  private Long productNotcontains;
  /**
   * 产品 比较(startswith)
   */
  private Long productStartswith;
  /**
   * 产品 比较(endswith)
   */
  private Long productEndswith;
  /**
   * 产品 比较(isnull)
   */
  private Boolean productIsnull;
  /**
   * 产品 比较(isnotnull)
   */
  private Boolean productIsnotnull;
  /**
   * 产品的品名 比较(eq)
   */
  private String productNameEq;
  /**
   * 产品的品名 比较(neq)
   */
  private String productNameNeq;
  /**
   * 产品的品名 比较(gt)
   */
  private String productNameGt;
  /**
   * 产品的品名 比较(gte)
   */
  private String productNameGte;
  /**
   * 产品的品名 比较(lt)
   */
  private String productNameLt;
  /**
   * 产品的品名 比较(lte)
   */
  private String productNameLte;
  /**
   * 产品的品名 比较(contains)
   */
  private String productNameContains;
  /**
   * 产品的品名 比较(notcontains)
   */
  private String productNameNotcontains;
  /**
   * 产品的品名 比较(startswith)
   */
  private String productNameStartswith;
  /**
   * 产品的品名 比较(endswith)
   */
  private String productNameEndswith;
  /**
   * 产品的品名 比较(isnull)
   */
  private Boolean productNameIsnull;
  /**
   * 产品的品名 比较(isnotnull)
   */
  private Boolean productNameIsnotnull;

  /**
   * 产品(范围搜索)
   */
  private List<Long> productInList;

  /**
   * SKU(模糊搜索)
   */
  private String sku;

  /**
   * SKU 比较(eq)
   */
  private String skuEq;
  /**
   * SKU 比较(neq)
   */
  private String skuNeq;
  /**
   * SKU 比较(gt)
   */
  private String skuGt;
  /**
   * SKU 比较(gte)
   */
  private String skuGte;
  /**
   * SKU 比较(lt)
   */
  private String skuLt;
  /**
   * SKU 比较(lte)
   */
  private String skuLte;
  /**
   * SKU 比较(contains)
   */
  private String skuContains;
  /**
   * SKU 比较(notcontains)
   */
  private String skuNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String skuStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String skuEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean skuIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean skuIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> skuInList;

  /**
   * 型号(模糊搜索)
   */
  private String model;

  /**
   * 型号 比较(eq)
   */
  private String modelEq;
  /**
   * 型号 比较(neq)
   */
  private String modelNeq;
  /**
   * 型号 比较(gt)
   */
  private String modelGt;
  /**
   * 型号 比较(gte)
   */
  private String modelGte;
  /**
   * 型号 比较(lt)
   */
  private String modelLt;
  /**
   * 型号 比较(lte)
   */
  private String modelLte;
  /**
   * 型号 比较(contains)
   */
  private String modelContains;
  /**
   * 型号 比较(notcontains)
   */
  private String modelNotcontains;
  /**
   * 型号 比较(startswith)
   */
  private String modelStartswith;
  /**
   * 型号 比较(endswith)
   */
  private String modelEndswith;
  /**
   * 型号 比较(isnull)
   */
  private Boolean modelIsnull;
  /**
   * 型号 比较(isnotnull)
   */
  private Boolean modelIsnotnull;

  /**
   * 型号(精确搜索)
   */
  private List<String> modelInList;

  /**
   * 标签(模糊搜索)
   */
  private String tags;

  /**
   * 标签 比较(eq)
   */
  private String tagsEq;
  /**
   * 标签 比较(neq)
   */
  private String tagsNeq;
  /**
   * 标签 比较(gt)
   */
  private String tagsGt;
  /**
   * 标签 比较(gte)
   */
  private String tagsGte;
  /**
   * 标签 比较(lt)
   */
  private String tagsLt;
  /**
   * 标签 比较(lte)
   */
  private String tagsLte;
  /**
   * 标签 比较(contains)
   */
  private String tagsContains;
  /**
   * 标签 比较(notcontains)
   */
  private String tagsNotcontains;
  /**
   * 标签 比较(startswith)
   */
  private String tagsStartswith;
  /**
   * 标签 比较(endswith)
   */
  private String tagsEndswith;
  /**
   * 标签 比较(isnull)
   */
  private Boolean tagsIsnull;
  /**
   * 标签 比较(isnotnull)
   */
  private Boolean tagsIsnotnull;

  /**
   * 标签(精确搜索)
   */
  private List<String> tagsInList;

  /**
   * 店铺
   */
  private Long sid;

  /**
   * 店铺 比较(eq)
   */
  private Long sidEq;
  /**
   * 店铺 比较(neq)
   */
  private Long sidNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long sidGt;
  /**
   * 店铺 比较(gte)
   */
  private Long sidGte;
  /**
   * 店铺 比较(lt)
   */
  private Long sidLt;
  /**
   * 店铺 比较(lte)
   */
  private Long sidLte;
  /**
   * 店铺 比较(contains)
   */
  private Long sidContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long sidNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long sidStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long sidEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean sidIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean sidIsnotnull;
  /**
   * 店铺的名称 比较(eq)
   */
  private String sidShopNameEq;
  /**
   * 店铺的名称 比较(neq)
   */
  private String sidShopNameNeq;
  /**
   * 店铺的名称 比较(gt)
   */
  private String sidShopNameGt;
  /**
   * 店铺的名称 比较(gte)
   */
  private String sidShopNameGte;
  /**
   * 店铺的名称 比较(lt)
   */
  private String sidShopNameLt;
  /**
   * 店铺的名称 比较(lte)
   */
  private String sidShopNameLte;
  /**
   * 店铺的名称 比较(contains)
   */
  private String sidShopNameContains;
  /**
   * 店铺的名称 比较(notcontains)
   */
  private String sidShopNameNotcontains;
  /**
   * 店铺的名称 比较(startswith)
   */
  private String sidShopNameStartswith;
  /**
   * 店铺的名称 比较(endswith)
   */
  private String sidShopNameEndswith;
  /**
   * 店铺的名称 比较(isnull)
   */
  private Boolean sidShopNameIsnull;
  /**
   * 店铺的名称 比较(isnotnull)
   */
  private Boolean sidShopNameIsnotnull;

  /**
   * 店铺(范围搜索)
   */
  private List<Long> sidInList;

  /**
   * 店铺名称(模糊搜索)
   */
  private String sellerName;

  /**
   * 店铺名称 比较(eq)
   */
  private String sellerNameEq;
  /**
   * 店铺名称 比较(neq)
   */
  private String sellerNameNeq;
  /**
   * 店铺名称 比较(gt)
   */
  private String sellerNameGt;
  /**
   * 店铺名称 比较(gte)
   */
  private String sellerNameGte;
  /**
   * 店铺名称 比较(lt)
   */
  private String sellerNameLt;
  /**
   * 店铺名称 比较(lte)
   */
  private String sellerNameLte;
  /**
   * 店铺名称 比较(contains)
   */
  private String sellerNameContains;
  /**
   * 店铺名称 比较(notcontains)
   */
  private String sellerNameNotcontains;
  /**
   * 店铺名称 比较(startswith)
   */
  private String sellerNameStartswith;
  /**
   * 店铺名称 比较(endswith)
   */
  private String sellerNameEndswith;
  /**
   * 店铺名称 比较(isnull)
   */
  private Boolean sellerNameIsnull;
  /**
   * 店铺名称 比较(isnotnull)
   */
  private Boolean sellerNameIsnotnull;

  /**
   * 店铺名称(精确搜索)
   */
  private List<String> sellerNameInList;

  /**
   * 国家(模糊搜索)
   */
  private String marketplace;

  /**
   * 国家 比较(eq)
   */
  private String marketplaceEq;
  /**
   * 国家 比较(neq)
   */
  private String marketplaceNeq;
  /**
   * 国家 比较(gt)
   */
  private String marketplaceGt;
  /**
   * 国家 比较(gte)
   */
  private String marketplaceGte;
  /**
   * 国家 比较(lt)
   */
  private String marketplaceLt;
  /**
   * 国家 比较(lte)
   */
  private String marketplaceLte;
  /**
   * 国家 比较(contains)
   */
  private String marketplaceContains;
  /**
   * 国家 比较(notcontains)
   */
  private String marketplaceNotcontains;
  /**
   * 国家 比较(startswith)
   */
  private String marketplaceStartswith;
  /**
   * 国家 比较(endswith)
   */
  private String marketplaceEndswith;
  /**
   * 国家 比较(isnull)
   */
  private Boolean marketplaceIsnull;
  /**
   * 国家 比较(isnotnull)
   */
  private Boolean marketplaceIsnotnull;

  /**
   * 国家(精确搜索)
   */
  private List<String> marketplaceInList;

  /**
   * FNSKU
   */
  private Long fnsku;

  /**
   * FNSKU 比较(eq)
   */
  private Long fnskuEq;
  /**
   * FNSKU 比较(neq)
   */
  private Long fnskuNeq;
  /**
   * FNSKU 比较(gt)
   */
  private Long fnskuGt;
  /**
   * FNSKU 比较(gte)
   */
  private Long fnskuGte;
  /**
   * FNSKU 比较(lt)
   */
  private Long fnskuLt;
  /**
   * FNSKU 比较(lte)
   */
  private Long fnskuLte;
  /**
   * FNSKU 比较(contains)
   */
  private Long fnskuContains;
  /**
   * FNSKU 比较(notcontains)
   */
  private Long fnskuNotcontains;
  /**
   * FNSKU 比较(startswith)
   */
  private Long fnskuStartswith;
  /**
   * FNSKU 比较(endswith)
   */
  private Long fnskuEndswith;
  /**
   * FNSKU 比较(isnull)
   */
  private Boolean fnskuIsnull;
  /**
   * FNSKU 比较(isnotnull)
   */
  private Boolean fnskuIsnotnull;
  /**
   * FNSKU的FNSKU 比较(eq)
   */
  private String fnskuFnskuEq;
  /**
   * FNSKU的FNSKU 比较(neq)
   */
  private String fnskuFnskuNeq;
  /**
   * FNSKU的FNSKU 比较(gt)
   */
  private String fnskuFnskuGt;
  /**
   * FNSKU的FNSKU 比较(gte)
   */
  private String fnskuFnskuGte;
  /**
   * FNSKU的FNSKU 比较(lt)
   */
  private String fnskuFnskuLt;
  /**
   * FNSKU的FNSKU 比较(lte)
   */
  private String fnskuFnskuLte;
  /**
   * FNSKU的FNSKU 比较(contains)
   */
  private String fnskuFnskuContains;
  /**
   * FNSKU的FNSKU 比较(notcontains)
   */
  private String fnskuFnskuNotcontains;
  /**
   * FNSKU的FNSKU 比较(startswith)
   */
  private String fnskuFnskuStartswith;
  /**
   * FNSKU的FNSKU 比较(endswith)
   */
  private String fnskuFnskuEndswith;
  /**
   * FNSKU的FNSKU 比较(isnull)
   */
  private Boolean fnskuFnskuIsnull;
  /**
   * FNSKU的FNSKU 比较(isnotnull)
   */
  private Boolean fnskuFnskuIsnotnull;

  /**
   * FNSKU(范围搜索)
   */
  private List<Long> fnskuInList;

  /**
   * MSKU(模糊搜索)
   */
  private String msku;

  /**
   * MSKU 比较(eq)
   */
  private String mskuEq;
  /**
   * MSKU 比较(neq)
   */
  private String mskuNeq;
  /**
   * MSKU 比较(gt)
   */
  private String mskuGt;
  /**
   * MSKU 比较(gte)
   */
  private String mskuGte;
  /**
   * MSKU 比较(lt)
   */
  private String mskuLt;
  /**
   * MSKU 比较(lte)
   */
  private String mskuLte;
  /**
   * MSKU 比较(contains)
   */
  private String mskuContains;
  /**
   * MSKU 比较(notcontains)
   */
  private String mskuNotcontains;
  /**
   * MSKU 比较(startswith)
   */
  private String mskuStartswith;
  /**
   * MSKU 比较(endswith)
   */
  private String mskuEndswith;
  /**
   * MSKU 比较(isnull)
   */
  private Boolean mskuIsnull;
  /**
   * MSKU 比较(isnotnull)
   */
  private Boolean mskuIsnotnull;

  /**
   * MSKU(精确搜索)
   */
  private List<String> mskuInList;

  /**
   * 供应商
   */
  private Long supplierId;

  /**
   * 供应商 比较(eq)
   */
  private Long supplierIdEq;
  /**
   * 供应商 比较(neq)
   */
  private Long supplierIdNeq;
  /**
   * 供应商 比较(gt)
   */
  private Long supplierIdGt;
  /**
   * 供应商 比较(gte)
   */
  private Long supplierIdGte;
  /**
   * 供应商 比较(lt)
   */
  private Long supplierIdLt;
  /**
   * 供应商 比较(lte)
   */
  private Long supplierIdLte;
  /**
   * 供应商 比较(contains)
   */
  private Long supplierIdContains;
  /**
   * 供应商 比较(notcontains)
   */
  private Long supplierIdNotcontains;
  /**
   * 供应商 比较(startswith)
   */
  private Long supplierIdStartswith;
  /**
   * 供应商 比较(endswith)
   */
  private Long supplierIdEndswith;
  /**
   * 供应商 比较(isnull)
   */
  private Boolean supplierIdIsnull;
  /**
   * 供应商 比较(isnotnull)
   */
  private Boolean supplierIdIsnotnull;
  /**
   * 供应商的供应商简称 比较(eq)
   */
  private String supplierIdSupplierNameEq;
  /**
   * 供应商的供应商简称 比较(neq)
   */
  private String supplierIdSupplierNameNeq;
  /**
   * 供应商的供应商简称 比较(gt)
   */
  private String supplierIdSupplierNameGt;
  /**
   * 供应商的供应商简称 比较(gte)
   */
  private String supplierIdSupplierNameGte;
  /**
   * 供应商的供应商简称 比较(lt)
   */
  private String supplierIdSupplierNameLt;
  /**
   * 供应商的供应商简称 比较(lte)
   */
  private String supplierIdSupplierNameLte;
  /**
   * 供应商的供应商简称 比较(contains)
   */
  private String supplierIdSupplierNameContains;
  /**
   * 供应商的供应商简称 比较(notcontains)
   */
  private String supplierIdSupplierNameNotcontains;
  /**
   * 供应商的供应商简称 比较(startswith)
   */
  private String supplierIdSupplierNameStartswith;
  /**
   * 供应商的供应商简称 比较(endswith)
   */
  private String supplierIdSupplierNameEndswith;
  /**
   * 供应商的供应商简称 比较(isnull)
   */
  private Boolean supplierIdSupplierNameIsnull;
  /**
   * 供应商的供应商简称 比较(isnotnull)
   */
  private Boolean supplierIdSupplierNameIsnotnull;

  /**
   * 供应商(范围搜索)
   */
  private List<Long> supplierIdInList;

  /**
   * 供应商名称(模糊搜索)
   */
  private String supplierName;

  /**
   * 供应商名称 比较(eq)
   */
  private String supplierNameEq;
  /**
   * 供应商名称 比较(neq)
   */
  private String supplierNameNeq;
  /**
   * 供应商名称 比较(gt)
   */
  private String supplierNameGt;
  /**
   * 供应商名称 比较(gte)
   */
  private String supplierNameGte;
  /**
   * 供应商名称 比较(lt)
   */
  private String supplierNameLt;
  /**
   * 供应商名称 比较(lte)
   */
  private String supplierNameLte;
  /**
   * 供应商名称 比较(contains)
   */
  private String supplierNameContains;
  /**
   * 供应商名称 比较(notcontains)
   */
  private String supplierNameNotcontains;
  /**
   * 供应商名称 比较(startswith)
   */
  private String supplierNameStartswith;
  /**
   * 供应商名称 比较(endswith)
   */
  private String supplierNameEndswith;
  /**
   * 供应商名称 比较(isnull)
   */
  private Boolean supplierNameIsnull;
  /**
   * 供应商名称 比较(isnotnull)
   */
  private Boolean supplierNameIsnotnull;

  /**
   * 供应商名称(精确搜索)
   */
  private List<String> supplierNameInList;

  /**
   * 仓库
   */
  private Long wid;

  /**
   * 仓库 比较(eq)
   */
  private Long widEq;
  /**
   * 仓库 比较(neq)
   */
  private Long widNeq;
  /**
   * 仓库 比较(gt)
   */
  private Long widGt;
  /**
   * 仓库 比较(gte)
   */
  private Long widGte;
  /**
   * 仓库 比较(lt)
   */
  private Long widLt;
  /**
   * 仓库 比较(lte)
   */
  private Long widLte;
  /**
   * 仓库 比较(contains)
   */
  private Long widContains;
  /**
   * 仓库 比较(notcontains)
   */
  private Long widNotcontains;
  /**
   * 仓库 比较(startswith)
   */
  private Long widStartswith;
  /**
   * 仓库 比较(endswith)
   */
  private Long widEndswith;
  /**
   * 仓库 比较(isnull)
   */
  private Boolean widIsnull;
  /**
   * 仓库 比较(isnotnull)
   */
  private Boolean widIsnotnull;
  /**
   * 仓库的仓库名称 比较(eq)
   */
  private String widNameEq;
  /**
   * 仓库的仓库名称 比较(neq)
   */
  private String widNameNeq;
  /**
   * 仓库的仓库名称 比较(gt)
   */
  private String widNameGt;
  /**
   * 仓库的仓库名称 比较(gte)
   */
  private String widNameGte;
  /**
   * 仓库的仓库名称 比较(lt)
   */
  private String widNameLt;
  /**
   * 仓库的仓库名称 比较(lte)
   */
  private String widNameLte;
  /**
   * 仓库的仓库名称 比较(contains)
   */
  private String widNameContains;
  /**
   * 仓库的仓库名称 比较(notcontains)
   */
  private String widNameNotcontains;
  /**
   * 仓库的仓库名称 比较(startswith)
   */
  private String widNameStartswith;
  /**
   * 仓库的仓库名称 比较(endswith)
   */
  private String widNameEndswith;
  /**
   * 仓库的仓库名称 比较(isnull)
   */
  private Boolean widNameIsnull;
  /**
   * 仓库的仓库名称 比较(isnotnull)
   */
  private Boolean widNameIsnotnull;

  /**
   * 仓库(范围搜索)
   */
  private List<Long> widInList;

  /**
   * 仓库名称(模糊搜索)
   */
  private String warehouseName;

  /**
   * 仓库名称 比较(eq)
   */
  private String warehouseNameEq;
  /**
   * 仓库名称 比较(neq)
   */
  private String warehouseNameNeq;
  /**
   * 仓库名称 比较(gt)
   */
  private String warehouseNameGt;
  /**
   * 仓库名称 比较(gte)
   */
  private String warehouseNameGte;
  /**
   * 仓库名称 比较(lt)
   */
  private String warehouseNameLt;
  /**
   * 仓库名称 比较(lte)
   */
  private String warehouseNameLte;
  /**
   * 仓库名称 比较(contains)
   */
  private String warehouseNameContains;
  /**
   * 仓库名称 比较(notcontains)
   */
  private String warehouseNameNotcontains;
  /**
   * 仓库名称 比较(startswith)
   */
  private String warehouseNameStartswith;
  /**
   * 仓库名称 比较(endswith)
   */
  private String warehouseNameEndswith;
  /**
   * 仓库名称 比较(isnull)
   */
  private Boolean warehouseNameIsnull;
  /**
   * 仓库名称 比较(isnotnull)
   */
  private Boolean warehouseNameIsnotnull;

  /**
   * 仓库名称(精确搜索)
   */
  private List<String> warehouseNameInList;

  /**
   * 单箱数量
   */
  private Integer cgBoxPcs;

  /**
   * 最小单箱数量
   */
  private Integer cgBoxPcsMin;

  /**
   * 最大单箱数量
   */
  private Integer cgBoxPcsMax;

  /**
   * 单箱数量 比较(eq)
   */
  private Integer cgBoxPcsEq;
  /**
   * 单箱数量 比较(neq)
   */
  private Integer cgBoxPcsNeq;
  /**
   * 单箱数量 比较(gt)
   */
  private Integer cgBoxPcsGt;
  /**
   * 单箱数量 比较(gte)
   */
  private Integer cgBoxPcsGte;
  /**
   * 单箱数量 比较(lt)
   */
  private Integer cgBoxPcsLt;
  /**
   * 单箱数量 比较(lte)
   */
  private Integer cgBoxPcsLte;
  /**
   * 单箱数量 比较(contains)
   */
  private Integer cgBoxPcsContains;
  /**
   * 单箱数量 比较(notcontains)
   */
  private Integer cgBoxPcsNotcontains;
  /**
   * 单箱数量 比较(startswith)
   */
  private Integer cgBoxPcsStartswith;
  /**
   * 单箱数量 比较(endswith)
   */
  private Integer cgBoxPcsEndswith;
  /**
   * 单箱数量 比较(isnull)
   */
  private Boolean cgBoxPcsIsnull;
  /**
   * 单箱数量 比较(isnotnull)
   */
  private Boolean cgBoxPcsIsnotnull;

  /**
   * 箱数
   */
  private Integer cgBoxNum;

  /**
   * 最小箱数
   */
  private Integer cgBoxNumMin;

  /**
   * 最大箱数
   */
  private Integer cgBoxNumMax;

  /**
   * 箱数 比较(eq)
   */
  private Integer cgBoxNumEq;
  /**
   * 箱数 比较(neq)
   */
  private Integer cgBoxNumNeq;
  /**
   * 箱数 比较(gt)
   */
  private Integer cgBoxNumGt;
  /**
   * 箱数 比较(gte)
   */
  private Integer cgBoxNumGte;
  /**
   * 箱数 比较(lt)
   */
  private Integer cgBoxNumLt;
  /**
   * 箱数 比较(lte)
   */
  private Integer cgBoxNumLte;
  /**
   * 箱数 比较(contains)
   */
  private Integer cgBoxNumContains;
  /**
   * 箱数 比较(notcontains)
   */
  private Integer cgBoxNumNotcontains;
  /**
   * 箱数 比较(startswith)
   */
  private Integer cgBoxNumStartswith;
  /**
   * 箱数 比较(endswith)
   */
  private Integer cgBoxNumEndswith;
  /**
   * 箱数 比较(isnull)
   */
  private Boolean cgBoxNumIsnull;
  /**
   * 箱数 比较(isnotnull)
   */
  private Boolean cgBoxNumIsnotnull;

  /**
   * 计划采购量
   */
  private Integer quantityPlan;

  /**
   * 最小计划采购量
   */
  private Integer quantityPlanMin;

  /**
   * 最大计划采购量
   */
  private Integer quantityPlanMax;

  /**
   * 计划采购量 比较(eq)
   */
  private Integer quantityPlanEq;
  /**
   * 计划采购量 比较(neq)
   */
  private Integer quantityPlanNeq;
  /**
   * 计划采购量 比较(gt)
   */
  private Integer quantityPlanGt;
  /**
   * 计划采购量 比较(gte)
   */
  private Integer quantityPlanGte;
  /**
   * 计划采购量 比较(lt)
   */
  private Integer quantityPlanLt;
  /**
   * 计划采购量 比较(lte)
   */
  private Integer quantityPlanLte;
  /**
   * 计划采购量 比较(contains)
   */
  private Integer quantityPlanContains;
  /**
   * 计划采购量 比较(notcontains)
   */
  private Integer quantityPlanNotcontains;
  /**
   * 计划采购量 比较(startswith)
   */
  private Integer quantityPlanStartswith;
  /**
   * 计划采购量 比较(endswith)
   */
  private Integer quantityPlanEndswith;
  /**
   * 计划采购量 比较(isnull)
   */
  private Boolean quantityPlanIsnull;
  /**
   * 计划采购量 比较(isnotnull)
   */
  private Boolean quantityPlanIsnotnull;

  /**
   * 建议采购量
   */
  private Integer quantitySuggestion;

  /**
   * 最小建议采购量
   */
  private Integer quantitySuggestionMin;

  /**
   * 最大建议采购量
   */
  private Integer quantitySuggestionMax;

  /**
   * 建议采购量 比较(eq)
   */
  private Integer quantitySuggestionEq;
  /**
   * 建议采购量 比较(neq)
   */
  private Integer quantitySuggestionNeq;
  /**
   * 建议采购量 比较(gt)
   */
  private Integer quantitySuggestionGt;
  /**
   * 建议采购量 比较(gte)
   */
  private Integer quantitySuggestionGte;
  /**
   * 建议采购量 比较(lt)
   */
  private Integer quantitySuggestionLt;
  /**
   * 建议采购量 比较(lte)
   */
  private Integer quantitySuggestionLte;
  /**
   * 建议采购量 比较(contains)
   */
  private Integer quantitySuggestionContains;
  /**
   * 建议采购量 比较(notcontains)
   */
  private Integer quantitySuggestionNotcontains;
  /**
   * 建议采购量 比较(startswith)
   */
  private Integer quantitySuggestionStartswith;
  /**
   * 建议采购量 比较(endswith)
   */
  private Integer quantitySuggestionEndswith;
  /**
   * 建议采购量 比较(isnull)
   */
  private Boolean quantitySuggestionIsnull;
  /**
   * 建议采购量 比较(isnotnull)
   */
  private Boolean quantitySuggestionIsnotnull;

  /**
   * 供应商报价ID
   */
  private Long psqId;

  /**
   * 供应商报价ID 比较(eq)
   */
  private Long psqIdEq;
  /**
   * 供应商报价ID 比较(neq)
   */
  private Long psqIdNeq;
  /**
   * 供应商报价ID 比较(gt)
   */
  private Long psqIdGt;
  /**
   * 供应商报价ID 比较(gte)
   */
  private Long psqIdGte;
  /**
   * 供应商报价ID 比较(lt)
   */
  private Long psqIdLt;
  /**
   * 供应商报价ID 比较(lte)
   */
  private Long psqIdLte;
  /**
   * 供应商报价ID 比较(contains)
   */
  private Long psqIdContains;
  /**
   * 供应商报价ID 比较(notcontains)
   */
  private Long psqIdNotcontains;
  /**
   * 供应商报价ID 比较(startswith)
   */
  private Long psqIdStartswith;
  /**
   * 供应商报价ID 比较(endswith)
   */
  private Long psqIdEndswith;
  /**
   * 供应商报价ID 比较(isnull)
   */
  private Boolean psqIdIsnull;
  /**
   * 供应商报价ID 比较(isnotnull)
   */
  private Boolean psqIdIsnotnull;
  /**
   * 供应商报价ID的工费 比较(eq)
   */
  private java.math.BigDecimal psqIdLaborCostEq;
  /**
   * 供应商报价ID的工费 比较(neq)
   */
  private java.math.BigDecimal psqIdLaborCostNeq;
  /**
   * 供应商报价ID的工费 比较(gt)
   */
  private java.math.BigDecimal psqIdLaborCostGt;
  /**
   * 供应商报价ID的工费 比较(gte)
   */
  private java.math.BigDecimal psqIdLaborCostGte;
  /**
   * 供应商报价ID的工费 比较(lt)
   */
  private java.math.BigDecimal psqIdLaborCostLt;
  /**
   * 供应商报价ID的工费 比较(lte)
   */
  private java.math.BigDecimal psqIdLaborCostLte;
  /**
   * 供应商报价ID的工费 比较(contains)
   */
  private java.math.BigDecimal psqIdLaborCostContains;
  /**
   * 供应商报价ID的工费 比较(notcontains)
   */
  private java.math.BigDecimal psqIdLaborCostNotcontains;
  /**
   * 供应商报价ID的工费 比较(startswith)
   */
  private java.math.BigDecimal psqIdLaborCostStartswith;
  /**
   * 供应商报价ID的工费 比较(endswith)
   */
  private java.math.BigDecimal psqIdLaborCostEndswith;
  /**
   * 供应商报价ID的工费 比较(isnull)
   */
  private Boolean psqIdLaborCostIsnull;
  /**
   * 供应商报价ID的工费 比较(isnotnull)
   */
  private Boolean psqIdLaborCostIsnotnull;

  /**
   * 供应商报价ID(范围搜索)
   */
  private List<Long> psqIdInList;

  /**
   * 供应商报价
   */
  private java.math.BigDecimal psq;

  /**
   * 最小供应商报价
   */
  private java.math.BigDecimal psqMin;

  /**
   * 最大供应商报价
   */
  private java.math.BigDecimal psqMax;

  /**
   * 供应商报价 比较(eq)
   */
  private java.math.BigDecimal psqEq;
  /**
   * 供应商报价 比较(neq)
   */
  private java.math.BigDecimal psqNeq;
  /**
   * 供应商报价 比较(gt)
   */
  private java.math.BigDecimal psqGt;
  /**
   * 供应商报价 比较(gte)
   */
  private java.math.BigDecimal psqGte;
  /**
   * 供应商报价 比较(lt)
   */
  private java.math.BigDecimal psqLt;
  /**
   * 供应商报价 比较(lte)
   */
  private java.math.BigDecimal psqLte;
  /**
   * 供应商报价 比较(contains)
   */
  private java.math.BigDecimal psqContains;
  /**
   * 供应商报价 比较(notcontains)
   */
  private java.math.BigDecimal psqNotcontains;
  /**
   * 供应商报价 比较(startswith)
   */
  private java.math.BigDecimal psqStartswith;
  /**
   * 供应商报价 比较(endswith)
   */
  private java.math.BigDecimal psqEndswith;
  /**
   * 供应商报价 比较(isnull)
   */
  private Boolean psqIsnull;
  /**
   * 供应商报价 比较(isnotnull)
   */
  private Boolean psqIsnotnull;

  /**
   * 采购数量
   */
  private Integer psqMod;

  /**
   * 最小采购数量
   */
  private Integer psqModMin;

  /**
   * 最大采购数量
   */
  private Integer psqModMax;

  /**
   * 采购数量 比较(eq)
   */
  private Integer psqModEq;
  /**
   * 采购数量 比较(neq)
   */
  private Integer psqModNeq;
  /**
   * 采购数量 比较(gt)
   */
  private Integer psqModGt;
  /**
   * 采购数量 比较(gte)
   */
  private Integer psqModGte;
  /**
   * 采购数量 比较(lt)
   */
  private Integer psqModLt;
  /**
   * 采购数量 比较(lte)
   */
  private Integer psqModLte;
  /**
   * 采购数量 比较(contains)
   */
  private Integer psqModContains;
  /**
   * 采购数量 比较(notcontains)
   */
  private Integer psqModNotcontains;
  /**
   * 采购数量 比较(startswith)
   */
  private Integer psqModStartswith;
  /**
   * 采购数量 比较(endswith)
   */
  private Integer psqModEndswith;
  /**
   * 采购数量 比较(isnull)
   */
  private Boolean psqModIsnull;
  /**
   * 采购数量 比较(isnotnull)
   */
  private Boolean psqModIsnotnull;

  /**
   * 含税单价
   */
  private java.math.BigDecimal psqPrice;

  /**
   * 最小含税单价
   */
  private java.math.BigDecimal psqPriceMin;

  /**
   * 最大含税单价
   */
  private java.math.BigDecimal psqPriceMax;

  /**
   * 含税单价 比较(eq)
   */
  private java.math.BigDecimal psqPriceEq;
  /**
   * 含税单价 比较(neq)
   */
  private java.math.BigDecimal psqPriceNeq;
  /**
   * 含税单价 比较(gt)
   */
  private java.math.BigDecimal psqPriceGt;
  /**
   * 含税单价 比较(gte)
   */
  private java.math.BigDecimal psqPriceGte;
  /**
   * 含税单价 比较(lt)
   */
  private java.math.BigDecimal psqPriceLt;
  /**
   * 含税单价 比较(lte)
   */
  private java.math.BigDecimal psqPriceLte;
  /**
   * 含税单价 比较(contains)
   */
  private java.math.BigDecimal psqPriceContains;
  /**
   * 含税单价 比较(notcontains)
   */
  private java.math.BigDecimal psqPriceNotcontains;
  /**
   * 含税单价 比较(startswith)
   */
  private java.math.BigDecimal psqPriceStartswith;
  /**
   * 含税单价 比较(endswith)
   */
  private java.math.BigDecimal psqPriceEndswith;
  /**
   * 含税单价 比较(isnull)
   */
  private Boolean psqPriceIsnull;
  /**
   * 含税单价 比较(isnotnull)
   */
  private Boolean psqPriceIsnotnull;

  /**
   * 已采购量
   */
  private Integer quantityPurchased;

  /**
   * 最小已采购量
   */
  private Integer quantityPurchasedMin;

  /**
   * 最大已采购量
   */
  private Integer quantityPurchasedMax;

  /**
   * 已采购量 比较(eq)
   */
  private Integer quantityPurchasedEq;
  /**
   * 已采购量 比较(neq)
   */
  private Integer quantityPurchasedNeq;
  /**
   * 已采购量 比较(gt)
   */
  private Integer quantityPurchasedGt;
  /**
   * 已采购量 比较(gte)
   */
  private Integer quantityPurchasedGte;
  /**
   * 已采购量 比较(lt)
   */
  private Integer quantityPurchasedLt;
  /**
   * 已采购量 比较(lte)
   */
  private Integer quantityPurchasedLte;
  /**
   * 已采购量 比较(contains)
   */
  private Integer quantityPurchasedContains;
  /**
   * 已采购量 比较(notcontains)
   */
  private Integer quantityPurchasedNotcontains;
  /**
   * 已采购量 比较(startswith)
   */
  private Integer quantityPurchasedStartswith;
  /**
   * 已采购量 比较(endswith)
   */
  private Integer quantityPurchasedEndswith;
  /**
   * 已采购量 比较(isnull)
   */
  private Boolean quantityPurchasedIsnull;
  /**
   * 已采购量 比较(isnotnull)
   */
  private Boolean quantityPurchasedIsnotnull;

  /**
   * 可用量
   */
  private Integer quantityAvailable;

  /**
   * 最小可用量
   */
  private Integer quantityAvailableMin;

  /**
   * 最大可用量
   */
  private Integer quantityAvailableMax;

  /**
   * 可用量 比较(eq)
   */
  private Integer quantityAvailableEq;
  /**
   * 可用量 比较(neq)
   */
  private Integer quantityAvailableNeq;
  /**
   * 可用量 比较(gt)
   */
  private Integer quantityAvailableGt;
  /**
   * 可用量 比较(gte)
   */
  private Integer quantityAvailableGte;
  /**
   * 可用量 比较(lt)
   */
  private Integer quantityAvailableLt;
  /**
   * 可用量 比较(lte)
   */
  private Integer quantityAvailableLte;
  /**
   * 可用量 比较(contains)
   */
  private Integer quantityAvailableContains;
  /**
   * 可用量 比较(notcontains)
   */
  private Integer quantityAvailableNotcontains;
  /**
   * 可用量 比较(startswith)
   */
  private Integer quantityAvailableStartswith;
  /**
   * 可用量 比较(endswith)
   */
  private Integer quantityAvailableEndswith;
  /**
   * 可用量 比较(isnull)
   */
  private Boolean quantityAvailableIsnull;
  /**
   * 可用量 比较(isnotnull)
   */
  private Boolean quantityAvailableIsnotnull;

  /**
   * 待检待上架量
   */
  private Integer quantityTest;

  /**
   * 最小待检待上架量
   */
  private Integer quantityTestMin;

  /**
   * 最大待检待上架量
   */
  private Integer quantityTestMax;

  /**
   * 待检待上架量 比较(eq)
   */
  private Integer quantityTestEq;
  /**
   * 待检待上架量 比较(neq)
   */
  private Integer quantityTestNeq;
  /**
   * 待检待上架量 比较(gt)
   */
  private Integer quantityTestGt;
  /**
   * 待检待上架量 比较(gte)
   */
  private Integer quantityTestGte;
  /**
   * 待检待上架量 比较(lt)
   */
  private Integer quantityTestLt;
  /**
   * 待检待上架量 比较(lte)
   */
  private Integer quantityTestLte;
  /**
   * 待检待上架量 比较(contains)
   */
  private Integer quantityTestContains;
  /**
   * 待检待上架量 比较(notcontains)
   */
  private Integer quantityTestNotcontains;
  /**
   * 待检待上架量 比较(startswith)
   */
  private Integer quantityTestStartswith;
  /**
   * 待检待上架量 比较(endswith)
   */
  private Integer quantityTestEndswith;
  /**
   * 待检待上架量 比较(isnull)
   */
  private Boolean quantityTestIsnull;
  /**
   * 待检待上架量 比较(isnotnull)
   */
  private Boolean quantityTestIsnotnull;

  /**
   * 待到货量
   */
  private Integer quantityAog;

  /**
   * 最小待到货量
   */
  private Integer quantityAogMin;

  /**
   * 最大待到货量
   */
  private Integer quantityAogMax;

  /**
   * 待到货量 比较(eq)
   */
  private Integer quantityAogEq;
  /**
   * 待到货量 比较(neq)
   */
  private Integer quantityAogNeq;
  /**
   * 待到货量 比较(gt)
   */
  private Integer quantityAogGt;
  /**
   * 待到货量 比较(gte)
   */
  private Integer quantityAogGte;
  /**
   * 待到货量 比较(lt)
   */
  private Integer quantityAogLt;
  /**
   * 待到货量 比较(lte)
   */
  private Integer quantityAogLte;
  /**
   * 待到货量 比较(contains)
   */
  private Integer quantityAogContains;
  /**
   * 待到货量 比较(notcontains)
   */
  private Integer quantityAogNotcontains;
  /**
   * 待到货量 比较(startswith)
   */
  private Integer quantityAogStartswith;
  /**
   * 待到货量 比较(endswith)
   */
  private Integer quantityAogEndswith;
  /**
   * 待到货量 比较(isnull)
   */
  private Boolean quantityAogIsnull;
  /**
   * 待到货量 比较(isnotnull)
   */
  private Boolean quantityAogIsnotnull;

  /**
   * 最早期望到货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date expectArriveTimeStart;

  /**
   * 最晚期望到货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date expectArriveTimeEnd;

  /**
   * 期望到货时间 比较(eq)
   */
  private Date expectArriveTimeEq;
  /**
   * 期望到货时间 比较(neq)
   */
  private Date expectArriveTimeNeq;
  /**
   * 期望到货时间 比较(gt)
   */
  private Date expectArriveTimeGt;
  /**
   * 期望到货时间 比较(gte)
   */
  private Date expectArriveTimeGte;
  /**
   * 期望到货时间 比较(lt)
   */
  private Date expectArriveTimeLt;
  /**
   * 期望到货时间 比较(lte)
   */
  private Date expectArriveTimeLte;
  /**
   * 期望到货时间 比较(contains)
   */
  private Date expectArriveTimeContains;
  /**
   * 期望到货时间 比较(notcontains)
   */
  private Date expectArriveTimeNotcontains;
  /**
   * 期望到货时间 比较(startswith)
   */
  private Date expectArriveTimeStartswith;
  /**
   * 期望到货时间 比较(endswith)
   */
  private Date expectArriveTimeEndswith;
  /**
   * 期望到货时间 比较(isnull)
   */
  private Boolean expectArriveTimeIsnull;
  /**
   * 期望到货时间 比较(isnotnull)
   */
  private Boolean expectArriveTimeIsnotnull;

  /**
   * 采购员
   */
  private Long cgUid;

  /**
   * 采购员 比较(eq)
   */
  private Long cgUidEq;
  /**
   * 采购员 比较(neq)
   */
  private Long cgUidNeq;
  /**
   * 采购员 比较(gt)
   */
  private Long cgUidGt;
  /**
   * 采购员 比较(gte)
   */
  private Long cgUidGte;
  /**
   * 采购员 比较(lt)
   */
  private Long cgUidLt;
  /**
   * 采购员 比较(lte)
   */
  private Long cgUidLte;
  /**
   * 采购员 比较(contains)
   */
  private Long cgUidContains;
  /**
   * 采购员 比较(notcontains)
   */
  private Long cgUidNotcontains;
  /**
   * 采购员 比较(startswith)
   */
  private Long cgUidStartswith;
  /**
   * 采购员 比较(endswith)
   */
  private Long cgUidEndswith;
  /**
   * 采购员 比较(isnull)
   */
  private Boolean cgUidIsnull;
  /**
   * 采购员 比较(isnotnull)
   */
  private Boolean cgUidIsnotnull;
  /**
   * 采购员的显示用户名 比较(eq)
   */
  private String cgUidNameEq;
  /**
   * 采购员的显示用户名 比较(neq)
   */
  private String cgUidNameNeq;
  /**
   * 采购员的显示用户名 比较(gt)
   */
  private String cgUidNameGt;
  /**
   * 采购员的显示用户名 比较(gte)
   */
  private String cgUidNameGte;
  /**
   * 采购员的显示用户名 比较(lt)
   */
  private String cgUidNameLt;
  /**
   * 采购员的显示用户名 比较(lte)
   */
  private String cgUidNameLte;
  /**
   * 采购员的显示用户名 比较(contains)
   */
  private String cgUidNameContains;
  /**
   * 采购员的显示用户名 比较(notcontains)
   */
  private String cgUidNameNotcontains;
  /**
   * 采购员的显示用户名 比较(startswith)
   */
  private String cgUidNameStartswith;
  /**
   * 采购员的显示用户名 比较(endswith)
   */
  private String cgUidNameEndswith;
  /**
   * 采购员的显示用户名 比较(isnull)
   */
  private Boolean cgUidNameIsnull;
  /**
   * 采购员的显示用户名 比较(isnotnull)
   */
  private Boolean cgUidNameIsnotnull;

  /**
   * 采购员(范围搜索)
   */
  private List<Long> cgUidInList;

  /**
   * 采购员名称(模糊搜索)
   */
  private String cgOptUsername;

  /**
   * 采购员名称 比较(eq)
   */
  private String cgOptUsernameEq;
  /**
   * 采购员名称 比较(neq)
   */
  private String cgOptUsernameNeq;
  /**
   * 采购员名称 比较(gt)
   */
  private String cgOptUsernameGt;
  /**
   * 采购员名称 比较(gte)
   */
  private String cgOptUsernameGte;
  /**
   * 采购员名称 比较(lt)
   */
  private String cgOptUsernameLt;
  /**
   * 采购员名称 比较(lte)
   */
  private String cgOptUsernameLte;
  /**
   * 采购员名称 比较(contains)
   */
  private String cgOptUsernameContains;
  /**
   * 采购员名称 比较(notcontains)
   */
  private String cgOptUsernameNotcontains;
  /**
   * 采购员名称 比较(startswith)
   */
  private String cgOptUsernameStartswith;
  /**
   * 采购员名称 比较(endswith)
   */
  private String cgOptUsernameEndswith;
  /**
   * 采购员名称 比较(isnull)
   */
  private Boolean cgOptUsernameIsnull;
  /**
   * 采购员名称 比较(isnotnull)
   */
  private Boolean cgOptUsernameIsnotnull;

  /**
   * 采购员名称(精确搜索)
   */
  private List<String> cgOptUsernameInList;

  /**
   * 备注(模糊搜索)
   */
  private String remark;

  /**
   * 备注 比较(eq)
   */
  private String remarkEq;
  /**
   * 备注 比较(neq)
   */
  private String remarkNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarkGt;
  /**
   * 备注 比较(gte)
   */
  private String remarkGte;
  /**
   * 备注 比较(lt)
   */
  private String remarkLt;
  /**
   * 备注 比较(lte)
   */
  private String remarkLte;
  /**
   * 备注 比较(contains)
   */
  private String remarkContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarkNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarkStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarkEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarkIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarkIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarkInList;

  /**
   * 状态
   */
  private String status;

  /**
   * 状态 比较(eq)
   */
  private String statusEq;
  /**
   * 状态 比较(neq)
   */
  private String statusNeq;
  /**
   * 状态 比较(gt)
   */
  private String statusGt;
  /**
   * 状态 比较(gte)
   */
  private String statusGte;
  /**
   * 状态 比较(lt)
   */
  private String statusLt;
  /**
   * 状态 比较(lte)
   */
  private String statusLte;
  /**
   * 状态 比较(contains)
   */
  private String statusContains;
  /**
   * 状态 比较(notcontains)
   */
  private String statusNotcontains;
  /**
   * 状态 比较(startswith)
   */
  private String statusStartswith;
  /**
   * 状态 比较(endswith)
   */
  private String statusEndswith;
  /**
   * 状态 比较(isnull)
   */
  private Boolean statusIsnull;
  /**
   * 状态 比较(isnotnull)
   */
  private Boolean statusIsnotnull;

  /**
   * 状态(精确搜索)
   */
  private List<String> statusInList;

  /**
   * 是否为组合商品
   */
  private String isCombo;

  /**
   * 是否为组合商品 比较(eq)
   */
  private String isComboEq;
  /**
   * 是否为组合商品 比较(neq)
   */
  private String isComboNeq;
  /**
   * 是否为组合商品 比较(gt)
   */
  private String isComboGt;
  /**
   * 是否为组合商品 比较(gte)
   */
  private String isComboGte;
  /**
   * 是否为组合商品 比较(lt)
   */
  private String isComboLt;
  /**
   * 是否为组合商品 比较(lte)
   */
  private String isComboLte;
  /**
   * 是否为组合商品 比较(contains)
   */
  private String isComboContains;
  /**
   * 是否为组合商品 比较(notcontains)
   */
  private String isComboNotcontains;
  /**
   * 是否为组合商品 比较(startswith)
   */
  private String isComboStartswith;
  /**
   * 是否为组合商品 比较(endswith)
   */
  private String isComboEndswith;
  /**
   * 是否为组合商品 比较(isnull)
   */
  private Boolean isComboIsnull;
  /**
   * 是否为组合商品 比较(isnotnull)
   */
  private Boolean isComboIsnotnull;

  /**
   * 是否为组合商品(精确搜索)
   */
  private List<String> isComboInList;

  /**
   * 是否为辅料
   */
  private String isAux;

  /**
   * 是否为辅料 比较(eq)
   */
  private String isAuxEq;
  /**
   * 是否为辅料 比较(neq)
   */
  private String isAuxNeq;
  /**
   * 是否为辅料 比较(gt)
   */
  private String isAuxGt;
  /**
   * 是否为辅料 比较(gte)
   */
  private String isAuxGte;
  /**
   * 是否为辅料 比较(lt)
   */
  private String isAuxLt;
  /**
   * 是否为辅料 比较(lte)
   */
  private String isAuxLte;
  /**
   * 是否为辅料 比较(contains)
   */
  private String isAuxContains;
  /**
   * 是否为辅料 比较(notcontains)
   */
  private String isAuxNotcontains;
  /**
   * 是否为辅料 比较(startswith)
   */
  private String isAuxStartswith;
  /**
   * 是否为辅料 比较(endswith)
   */
  private String isAuxEndswith;
  /**
   * 是否为辅料 比较(isnull)
   */
  private Boolean isAuxIsnull;
  /**
   * 是否为辅料 比较(isnotnull)
   */
  private Boolean isAuxIsnotnull;

  /**
   * 是否为辅料(精确搜索)
   */
  private List<String> isAuxInList;

  /**
   * 是否关联了加工计划
   */
  private String isRelatedProcessPlan;

  /**
   * 是否关联了加工计划 比较(eq)
   */
  private String isRelatedProcessPlanEq;
  /**
   * 是否关联了加工计划 比较(neq)
   */
  private String isRelatedProcessPlanNeq;
  /**
   * 是否关联了加工计划 比较(gt)
   */
  private String isRelatedProcessPlanGt;
  /**
   * 是否关联了加工计划 比较(gte)
   */
  private String isRelatedProcessPlanGte;
  /**
   * 是否关联了加工计划 比较(lt)
   */
  private String isRelatedProcessPlanLt;
  /**
   * 是否关联了加工计划 比较(lte)
   */
  private String isRelatedProcessPlanLte;
  /**
   * 是否关联了加工计划 比较(contains)
   */
  private String isRelatedProcessPlanContains;
  /**
   * 是否关联了加工计划 比较(notcontains)
   */
  private String isRelatedProcessPlanNotcontains;
  /**
   * 是否关联了加工计划 比较(startswith)
   */
  private String isRelatedProcessPlanStartswith;
  /**
   * 是否关联了加工计划 比较(endswith)
   */
  private String isRelatedProcessPlanEndswith;
  /**
   * 是否关联了加工计划 比较(isnull)
   */
  private Boolean isRelatedProcessPlanIsnull;
  /**
   * 是否关联了加工计划 比较(isnotnull)
   */
  private Boolean isRelatedProcessPlanIsnotnull;

  /**
   * 是否关联了加工计划(精确搜索)
   */
  private List<String> isRelatedProcessPlanInList;

  /**
   * 采购计划批次号
   */
  private String planId;

  /**
   * 采购计划批次号 比较(eq)
   */
  private String planIdEq;
  /**
   * 采购计划批次号 比较(neq)
   */
  private String planIdNeq;
  /**
   * 采购计划批次号 比较(gt)
   */
  private String planIdGt;
  /**
   * 采购计划批次号 比较(gte)
   */
  private String planIdGte;
  /**
   * 采购计划批次号 比较(lt)
   */
  private String planIdLt;
  /**
   * 采购计划批次号 比较(lte)
   */
  private String planIdLte;
  /**
   * 采购计划批次号 比较(contains)
   */
  private String planIdContains;
  /**
   * 采购计划批次号 比较(notcontains)
   */
  private String planIdNotcontains;
  /**
   * 采购计划批次号 比较(startswith)
   */
  private String planIdStartswith;
  /**
   * 采购计划批次号 比较(endswith)
   */
  private String planIdEndswith;
  /**
   * 采购计划批次号 比较(isnull)
   */
  private Boolean planIdIsnull;
  /**
   * 采购计划批次号 比较(isnotnull)
   */
  private Boolean planIdIsnotnull;

  /**
   * 采购计划批次号(精确搜索)
   */
  private List<String> planIdInList;

  /**
   * 加急处理
   */
  private String isPrioritized;

  /**
   * 加急处理 比较(eq)
   */
  private String isPrioritizedEq;
  /**
   * 加急处理 比较(neq)
   */
  private String isPrioritizedNeq;
  /**
   * 加急处理 比较(gt)
   */
  private String isPrioritizedGt;
  /**
   * 加急处理 比较(gte)
   */
  private String isPrioritizedGte;
  /**
   * 加急处理 比较(lt)
   */
  private String isPrioritizedLt;
  /**
   * 加急处理 比较(lte)
   */
  private String isPrioritizedLte;
  /**
   * 加急处理 比较(contains)
   */
  private String isPrioritizedContains;
  /**
   * 加急处理 比较(notcontains)
   */
  private String isPrioritizedNotcontains;
  /**
   * 加急处理 比较(startswith)
   */
  private String isPrioritizedStartswith;
  /**
   * 加急处理 比较(endswith)
   */
  private String isPrioritizedEndswith;
  /**
   * 加急处理 比较(isnull)
   */
  private Boolean isPrioritizedIsnull;
  /**
   * 加急处理 比较(isnotnull)
   */
  private Boolean isPrioritizedIsnotnull;

  /**
   * 加急处理(精确搜索)
   */
  private List<String> isPrioritizedInList;

  /**
   * 未采购量
   */
  private Integer noQuantityPurchased;

  /**
   * 最小未采购量
   */
  private Integer noQuantityPurchasedMin;

  /**
   * 最大未采购量
   */
  private Integer noQuantityPurchasedMax;

  /**
   * 未采购量 比较(eq)
   */
  private Integer noQuantityPurchasedEq;
  /**
   * 未采购量 比较(neq)
   */
  private Integer noQuantityPurchasedNeq;
  /**
   * 未采购量 比较(gt)
   */
  private Integer noQuantityPurchasedGt;
  /**
   * 未采购量 比较(gte)
   */
  private Integer noQuantityPurchasedGte;
  /**
   * 未采购量 比较(lt)
   */
  private Integer noQuantityPurchasedLt;
  /**
   * 未采购量 比较(lte)
   */
  private Integer noQuantityPurchasedLte;
  /**
   * 未采购量 比较(contains)
   */
  private Integer noQuantityPurchasedContains;
  /**
   * 未采购量 比较(notcontains)
   */
  private Integer noQuantityPurchasedNotcontains;
  /**
   * 未采购量 比较(startswith)
   */
  private Integer noQuantityPurchasedStartswith;
  /**
   * 未采购量 比较(endswith)
   */
  private Integer noQuantityPurchasedEndswith;
  /**
   * 未采购量 比较(isnull)
   */
  private Boolean noQuantityPurchasedIsnull;
  /**
   * 未采购量 比较(isnotnull)
   */
  private Boolean noQuantityPurchasedIsnotnull;

  /**
   * sid2
   */
  private Integer sid2;

  /**
   * 最小sid2
   */
  private Integer sid2Min;

  /**
   * 最大sid2
   */
  private Integer sid2Max;

  /**
   * sid2 比较(eq)
   */
  private Integer sid2Eq;
  /**
   * sid2 比较(neq)
   */
  private Integer sid2Neq;
  /**
   * sid2 比较(gt)
   */
  private Integer sid2Gt;
  /**
   * sid2 比较(gte)
   */
  private Integer sid2Gte;
  /**
   * sid2 比较(lt)
   */
  private Integer sid2Lt;
  /**
   * sid2 比较(lte)
   */
  private Integer sid2Lte;
  /**
   * sid2 比较(contains)
   */
  private Integer sid2Contains;
  /**
   * sid2 比较(notcontains)
   */
  private Integer sid2Notcontains;
  /**
   * sid2 比较(startswith)
   */
  private Integer sid2Startswith;
  /**
   * sid2 比较(endswith)
   */
  private Integer sid2Endswith;
  /**
   * sid2 比较(isnull)
   */
  private Boolean sid2Isnull;
  /**
   * sid2 比较(isnotnull)
   */
  private Boolean sid2Isnotnull;

  /**
   * 本地库龄(模糊搜索)
   */
  private String localDayList;

  /**
   * 本地库龄 比较(eq)
   */
  private String localDayListEq;
  /**
   * 本地库龄 比较(neq)
   */
  private String localDayListNeq;
  /**
   * 本地库龄 比较(gt)
   */
  private String localDayListGt;
  /**
   * 本地库龄 比较(gte)
   */
  private String localDayListGte;
  /**
   * 本地库龄 比较(lt)
   */
  private String localDayListLt;
  /**
   * 本地库龄 比较(lte)
   */
  private String localDayListLte;
  /**
   * 本地库龄 比较(contains)
   */
  private String localDayListContains;
  /**
   * 本地库龄 比较(notcontains)
   */
  private String localDayListNotcontains;
  /**
   * 本地库龄 比较(startswith)
   */
  private String localDayListStartswith;
  /**
   * 本地库龄 比较(endswith)
   */
  private String localDayListEndswith;
  /**
   * 本地库龄 比较(isnull)
   */
  private Boolean localDayListIsnull;
  /**
   * 本地库龄 比较(isnotnull)
   */
  private Boolean localDayListIsnotnull;

  /**
   * 本地库龄(精确搜索)
   */
  private List<String> localDayListInList;

  /**
   * fba(模糊搜索)
   */
  private String fbaDayList;

  /**
   * fba 比较(eq)
   */
  private String fbaDayListEq;
  /**
   * fba 比较(neq)
   */
  private String fbaDayListNeq;
  /**
   * fba 比较(gt)
   */
  private String fbaDayListGt;
  /**
   * fba 比较(gte)
   */
  private String fbaDayListGte;
  /**
   * fba 比较(lt)
   */
  private String fbaDayListLt;
  /**
   * fba 比较(lte)
   */
  private String fbaDayListLte;
  /**
   * fba 比较(contains)
   */
  private String fbaDayListContains;
  /**
   * fba 比较(notcontains)
   */
  private String fbaDayListNotcontains;
  /**
   * fba 比较(startswith)
   */
  private String fbaDayListStartswith;
  /**
   * fba 比较(endswith)
   */
  private String fbaDayListEndswith;
  /**
   * fba 比较(isnull)
   */
  private Boolean fbaDayListIsnull;
  /**
   * fba 比较(isnotnull)
   */
  private Boolean fbaDayListIsnotnull;

  /**
   * fba(精确搜索)
   */
  private List<String> fbaDayListInList;

  /**
   * 销量(模糊搜索)
   */
  private String skuSales;

  /**
   * 销量 比较(eq)
   */
  private String skuSalesEq;
  /**
   * 销量 比较(neq)
   */
  private String skuSalesNeq;
  /**
   * 销量 比较(gt)
   */
  private String skuSalesGt;
  /**
   * 销量 比较(gte)
   */
  private String skuSalesGte;
  /**
   * 销量 比较(lt)
   */
  private String skuSalesLt;
  /**
   * 销量 比较(lte)
   */
  private String skuSalesLte;
  /**
   * 销量 比较(contains)
   */
  private String skuSalesContains;
  /**
   * 销量 比较(notcontains)
   */
  private String skuSalesNotcontains;
  /**
   * 销量 比较(startswith)
   */
  private String skuSalesStartswith;
  /**
   * 销量 比较(endswith)
   */
  private String skuSalesEndswith;
  /**
   * 销量 比较(isnull)
   */
  private Boolean skuSalesIsnull;
  /**
   * 销量 比较(isnotnull)
   */
  private Boolean skuSalesIsnotnull;

  /**
   * 销量(精确搜索)
   */
  private List<String> skuSalesInList;

  /**
   * 最早开始销售日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date startSalesDateStart;

  /**
   * 最晚开始销售日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date startSalesDateEnd;

  /**
   * 开始销售日期 比较(eq)
   */
  private Date startSalesDateEq;
  /**
   * 开始销售日期 比较(neq)
   */
  private Date startSalesDateNeq;
  /**
   * 开始销售日期 比较(gt)
   */
  private Date startSalesDateGt;
  /**
   * 开始销售日期 比较(gte)
   */
  private Date startSalesDateGte;
  /**
   * 开始销售日期 比较(lt)
   */
  private Date startSalesDateLt;
  /**
   * 开始销售日期 比较(lte)
   */
  private Date startSalesDateLte;
  /**
   * 开始销售日期 比较(contains)
   */
  private Date startSalesDateContains;
  /**
   * 开始销售日期 比较(notcontains)
   */
  private Date startSalesDateNotcontains;
  /**
   * 开始销售日期 比较(startswith)
   */
  private Date startSalesDateStartswith;
  /**
   * 开始销售日期 比较(endswith)
   */
  private Date startSalesDateEndswith;
  /**
   * 开始销售日期 比较(isnull)
   */
  private Boolean startSalesDateIsnull;
  /**
   * 开始销售日期 比较(isnotnull)
   */
  private Boolean startSalesDateIsnotnull;

  /**
   * 最早结束销售日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date endSalesDateStart;

  /**
   * 最晚结束销售日期
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date endSalesDateEnd;

  /**
   * 结束销售日期 比较(eq)
   */
  private Date endSalesDateEq;
  /**
   * 结束销售日期 比较(neq)
   */
  private Date endSalesDateNeq;
  /**
   * 结束销售日期 比较(gt)
   */
  private Date endSalesDateGt;
  /**
   * 结束销售日期 比较(gte)
   */
  private Date endSalesDateGte;
  /**
   * 结束销售日期 比较(lt)
   */
  private Date endSalesDateLt;
  /**
   * 结束销售日期 比较(lte)
   */
  private Date endSalesDateLte;
  /**
   * 结束销售日期 比较(contains)
   */
  private Date endSalesDateContains;
  /**
   * 结束销售日期 比较(notcontains)
   */
  private Date endSalesDateNotcontains;
  /**
   * 结束销售日期 比较(startswith)
   */
  private Date endSalesDateStartswith;
  /**
   * 结束销售日期 比较(endswith)
   */
  private Date endSalesDateEndswith;
  /**
   * 结束销售日期 比较(isnull)
   */
  private Boolean endSalesDateIsnull;
  /**
   * 结束销售日期 比较(isnotnull)
   */
  private Boolean endSalesDateIsnotnull;

  /**
   * 同期销量
   */
  private Long sameSales;

  /**
   * 最小同期销量
   */
  private Long sameSalesMin;

  /**
   * 最大同期销量
   */
  private Long sameSalesMax;

  /**
   * 同期销量 比较(eq)
   */
  private Long sameSalesEq;
  /**
   * 同期销量 比较(neq)
   */
  private Long sameSalesNeq;
  /**
   * 同期销量 比较(gt)
   */
  private Long sameSalesGt;
  /**
   * 同期销量 比较(gte)
   */
  private Long sameSalesGte;
  /**
   * 同期销量 比较(lt)
   */
  private Long sameSalesLt;
  /**
   * 同期销量 比较(lte)
   */
  private Long sameSalesLte;
  /**
   * 同期销量 比较(contains)
   */
  private Long sameSalesContains;
  /**
   * 同期销量 比较(notcontains)
   */
  private Long sameSalesNotcontains;
  /**
   * 同期销量 比较(startswith)
   */
  private Long sameSalesStartswith;
  /**
   * 同期销量 比较(endswith)
   */
  private Long sameSalesEndswith;
  /**
   * 同期销量 比较(isnull)
   */
  private Boolean sameSalesIsnull;
  /**
   * 同期销量 比较(isnotnull)
   */
  private Boolean sameSalesIsnotnull;

  /**
   * fnsku(模糊搜索)
   */
  private String fnskuName;

  /**
   * fnsku 比较(eq)
   */
  private String fnskuNameEq;
  /**
   * fnsku 比较(neq)
   */
  private String fnskuNameNeq;
  /**
   * fnsku 比较(gt)
   */
  private String fnskuNameGt;
  /**
   * fnsku 比较(gte)
   */
  private String fnskuNameGte;
  /**
   * fnsku 比较(lt)
   */
  private String fnskuNameLt;
  /**
   * fnsku 比较(lte)
   */
  private String fnskuNameLte;
  /**
   * fnsku 比较(contains)
   */
  private String fnskuNameContains;
  /**
   * fnsku 比较(notcontains)
   */
  private String fnskuNameNotcontains;
  /**
   * fnsku 比较(startswith)
   */
  private String fnskuNameStartswith;
  /**
   * fnsku 比较(endswith)
   */
  private String fnskuNameEndswith;
  /**
   * fnsku 比较(isnull)
   */
  private Boolean fnskuNameIsnull;
  /**
   * fnsku 比较(isnotnull)
   */
  private Boolean fnskuNameIsnotnull;

  /**
   * fnsku(精确搜索)
   */
  private List<String> fnskuNameInList;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
